/*
 * Copyright (c) 2012, 2013, Oracle and/or its affiliates. All rights reserved.
 * ORACLE PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 *
 */
package java.util.stream;

/**
 * Base class for a data structure for gathering elements into a buffer and then
 * iterating them. Maintains an array of increasingly sized arrays, so there is
 * no copying cost associated with growing the data structure.
 *
 * @since 1.8
 */
abstract class AbstractSpinedBuffer {

  /**
   * Minimum power-of-two for the first chunk.
   */
  public static final int MIN_CHUNK_POWER = 4;

  /**
   * Minimum size for the first chunk.
   */
  public static final int MIN_CHUNK_SIZE = 1 << MIN_CHUNK_POWER;

  /**
   * Max power-of-two for chunks.
   */
  public static final int MAX_CHUNK_POWER = 30;

  /**
   * Minimum array size for array-of-chunks.
   */
  public static final int MIN_SPINE_SIZE = 8;


  /**
   * log2 of the size of the first chunk.
   */
  protected final int initialChunkPower;

  /**
   * Index of the *next* element to write; may point into, or just outside of,
   * the current chunk.
   */
  protected int elementIndex;

  /**
   * Index of the *current* chunk in the spine array, if the spine array is
   * non-null.
   */
  protected int spineIndex;

  /**
   * Count of elements in all prior chunks.
   */
  protected long[] priorElementCount;

  /**
   * Construct with an initial capacity of 16.
   */
  protected AbstractSpinedBuffer() {
    this.initialChunkPower = MIN_CHUNK_POWER;
  }

  /**
   * Construct with a specified initial capacity.
   *
   * @param initialCapacity The minimum expected number of elements
   */
  protected AbstractSpinedBuffer(int initialCapacity) {
    if (initialCapacity < 0) {
      throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);
    }

    this.initialChunkPower = Math.max(MIN_CHUNK_POWER,
        Integer.SIZE - Integer.numberOfLeadingZeros(initialCapacity - 1));
  }

  /**
   * Is the buffer currently empty?
   */
  public boolean isEmpty() {
    return (spineIndex == 0) && (elementIndex == 0);
  }

  /**
   * How many elements are currently in the buffer?
   */
  public long count() {
    return (spineIndex == 0)
        ? elementIndex
        : priorElementCount[spineIndex] + elementIndex;
  }

  /**
   * How big should the nth chunk be?
   */
  protected int chunkSize(int n) {
    int power = (n == 0 || n == 1)
        ? initialChunkPower
        : Math.min(initialChunkPower + n - 1, AbstractSpinedBuffer.MAX_CHUNK_POWER);
    return 1 << power;
  }

  /**
   * Remove all data from the buffer
   */
  public abstract void clear();
}
